package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.CostRequest;
import com.ruoyi.system.domain.vo.zbg.AnnualCostDataVo;
import com.ruoyi.system.domain.zbg.AnnualCostData;
import com.ruoyi.system.domain.zbg.CostData;
import com.ruoyi.system.mapper.AnnualCostDataMapper;
import com.ruoyi.system.mapper.CostDataMapper;
import com.ruoyi.system.mapper.MonthlyRepairDataMapper;
import com.ruoyi.system.service.AnnualCostDataService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;

@Service
public class AnnualCostDataServiceImpl extends ServiceImpl<AnnualCostDataMapper, AnnualCostData> implements AnnualCostDataService {
    @Autowired
    private AnnualCostDataMapper annualCostDataMapper;
    @Autowired
    private MonthlyRepairDataMapper monthlyRepairDataMapper;
    @Autowired
    private CostDataMapper costDataMapper;

    @Transactional(rollbackFor = Exception.class)
    public void saveAll(List<AnnualCostData> annualCostDataList) {
//        annualCostDataList.forEach(annualCostDataMapper::insert);
        annualCostDataList.forEach(annualCostDataMapper::saveOrUpdate);
    }

    @Override
    public List<AnnualCostDataVo> getCostMaintenanceData(CostRequest costRequest) {
        int year = 0;
        if (ObjectUtils.isNotEmpty(costRequest.getYear())) {
            year = costRequest.getYear();
        } else if (ObjectUtils.isEmpty(costRequest.getYear())) {
            //获取当前年份
            year = DateUtils.getNowYear();
        }
        List<AnnualCostDataVo> annualCostDataVos = new ArrayList<>();
        //判断查询的类型
        if (ObjectUtils.isNotEmpty(costRequest.getType())) {

            if (costRequest.getType() == 1) {
                //如果是维修费
                return getCostDataVos(costRequest, year);
            } else if (costRequest.getType() == 2) {
                //如果是电费

                 annualCostDataVos = getelectricCostDataVos(costRequest, year);
                ArrayList<AnnualCostDataVo> annualCostDataVos1 = new ArrayList<>();
                //将额度电费排名进度信息放到维修费返回数据中
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVos) {
                    AnnualCostDataVo annualCostDataVo1 = new AnnualCostDataVo();
                    annualCostDataVo1.setDistrict(annualCostDataVo.getDistrict());
                    annualCostDataVo1.setTotalRepairQuota(annualCostDataVo.getElectricQuota());
                    annualCostDataVo1.setUsedRepairQuota(annualCostDataVo.getUsedElectricQuota());
                    annualCostDataVo1.setProgressRepairQuota(annualCostDataVo.getProgressElectricQuota());
                    annualCostDataVo1.setRankRepairQuota(annualCostDataVo.getRankElectricQuota());
                    annualCostDataVos1.add(annualCostDataVo1);
                }
                return annualCostDataVos1;
            }else if (costRequest.getType() == 3){
                //如果是塔费
                annualCostDataVos = getTowerCostDataVos(costRequest, year);
                ArrayList<AnnualCostDataVo> annualCostDataVos1 = new ArrayList<>();
                //将额度塔费排名进度信息放到维修费返回数据中
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVos) {
                    AnnualCostDataVo annualCostDataVo1 = new AnnualCostDataVo();
                    annualCostDataVo1.setDistrict(annualCostDataVo.getDistrict());
                    annualCostDataVo1.setTotalRepairQuota(annualCostDataVo.getTowerQuota());
                    annualCostDataVo1.setUsedRepairQuota(annualCostDataVo.getUsedTowerQuota());
                    annualCostDataVo1.setProgressRepairQuota(annualCostDataVo.getProgressTowerQuota());
                    annualCostDataVo1.setRankRepairQuota(annualCostDataVo.getRankTowerQuota());
                    annualCostDataVos1.add(annualCostDataVo1);
                }
                return annualCostDataVos1;

            }else if (costRequest.getType() == 4){
                //网络产品增收
                 annualCostDataVos = getNetworkProductDataVos(costRequest, year);
                 ArrayList<AnnualCostDataVo> annualCostDataVos1 = new ArrayList<>();
                //将额度网络产品增收排名进度信息放到维修费返回数据中
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVos) {
                    AnnualCostDataVo annualCostDataVo1 = new AnnualCostDataVo();
                    annualCostDataVo1.setDistrict(annualCostDataVo.getDistrict());
                    annualCostDataVo1.setTotalRepairQuota(annualCostDataVo.getNetworkQuota());
                    annualCostDataVo1.setUsedRepairQuota(annualCostDataVo.getUsedNetworkQuota());
                    annualCostDataVo1.setProgressRepairQuota(annualCostDataVo.getProgressNetworkQuota());
                    annualCostDataVo1.setRankRepairQuota(annualCostDataVo.getRankNetworkQuota());
                    annualCostDataVos1.add(annualCostDataVo1);
                }
                return annualCostDataVos1;

            }else if (costRequest.getType() == 5){
                //赔补
                annualCostDataVos = getCompensationDataVos(costRequest, year);
                ArrayList<AnnualCostDataVo> annualCostDataVos1 = new ArrayList<>();
                //将额度赔补排名进度信息放到维修费返回数据中
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVos) {
                    AnnualCostDataVo annualCostDataVo1 = new AnnualCostDataVo();
                    annualCostDataVo1.setDistrict(annualCostDataVo.getDistrict());
                    annualCostDataVo1.setTotalRepairQuota(annualCostDataVo.getCompensationQuota());
                    annualCostDataVo1.setUsedRepairQuota(annualCostDataVo.getUsedCompensationQuota());
                    annualCostDataVo1.setProgressRepairQuota(annualCostDataVo.getProgressCompensationQuota());
                    annualCostDataVo1.setRankRepairQuota(annualCostDataVo.getRankCompensationQuota());
                    annualCostDataVos1.add(annualCostDataVo1);
                }
                return annualCostDataVos1;
            }

        }
        return new ArrayList<>();


    }

    private List<AnnualCostDataVo> getCompensationDataVos(CostRequest costRequest, int year) {
        //判断是不是查询月份数据
        if (ObjectUtils.isEmpty(costRequest.getMonth())) {
            //查询年度赔补数据
            List<AnnualCostDataVo> annualCostDataVoList = annualCostDataMapper.selectYear(year);
            //判断集合是否为空
            if (CollectionUtils.isEmpty(annualCostDataVoList)) {
                throw new RuntimeException("该年份没有数据");
            }
            //对数据进行遍历，获取实际使用情况
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                //获取区域名称
                String areaName = annualCostDataVo.getDistrict();
                //根据区域名称获取当年实际的赔部情况
                Double count = costDataMapper.selectCompensationCountByAreaAndYear(year, areaName);
                annualCostDataVo.setUsedCompensationQuota(count);
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(annualCostDataVo.getCompensationQuota()) && ObjectUtils.isNotEmpty(count)) {
                    double usedRate = (count / annualCostDataVo.getCompensationQuota()) * 100;
                    annualCostDataVo.setProgressCompensationQuota(String.format("%.2f", usedRate) + "%");
                }
            }
            // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressCompensationQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressCompensationQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名  赔补暂时没有排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressCompensationQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressCompensationQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankCompensationQuota(rank);
                    lastUsedRate = usedRate;
                }
            }
            return annualCostDataVoList;

        }else {
            //查询的是该年该月的数据，使用月度赔补即可
            QueryWrapper<CostData> costDataQueryWrapper = new QueryWrapper<>();
            costDataQueryWrapper.eq("cost_year", year);
            costDataQueryWrapper.eq("cost_month", costRequest.getMonth());
            List<CostData> costData = costDataMapper.selectList(costDataQueryWrapper);
            if (CollectionUtils.isEmpty(costData)) {
                throw new RuntimeException("该年月没有数据");
            }
            //创建返回对象列表
            List<AnnualCostDataVo> annualCostDataVoList = new ArrayList<>();
            //遍历每月成本数据，获取每月赔补情况
            for (CostData costDatum : costData) {
                //创建返回对象
                AnnualCostDataVo annualCostDataVo = new AnnualCostDataVo();
                //设置区域名称
                annualCostDataVo.setDistrict(costDatum.getDistrict());
                //设置月度赔补额度
                annualCostDataVo.setCompensationQuota(costDatum.getCompensationQuota());
                //实际使用情况
                annualCostDataVo.setUsedCompensationQuota(costDatum.getCompensationUsed());
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(costDatum.getCompensationQuota()) && ObjectUtils.isNotEmpty(costDatum.getCompensationUsed())) {
                    double usedRate = (costDatum.getCompensationUsed() / costDatum.getCompensationQuota()) * 100;
                    annualCostDataVo.setProgressCompensationQuota(String.format("%.2f", usedRate) + "%");
                }
                annualCostDataVoList.add(annualCostDataVo);
            }

            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressCompensationQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressCompensationQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressCompensationQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressCompensationQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankCompensationQuota(rank);
                    lastUsedRate = usedRate;
                }
            }
            return annualCostDataVoList;
        }


    }

    private List<AnnualCostDataVo> getNetworkProductDataVos(CostRequest costRequest, int year) {
        //判断是不是查询月份数据
        if (ObjectUtils.isEmpty(costRequest.getMonth())) {
            //查询年度网络产品增收数据
            List<AnnualCostDataVo> annualCostDataVoList = annualCostDataMapper.selectYear(year);
            //判断集合是否为空
            if (CollectionUtils.isEmpty(annualCostDataVoList)) {
                throw new RuntimeException("该年份没有数据");
            }
            //对数据进行遍历，获取实际使用情况
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                //获取区域名称
                String areaName = annualCostDataVo.getDistrict();
                //根据区域名称获取当年实际的网络产品增收情况
                Double count = costDataMapper.selctnetworkProductCountByAreaAndYear(year, areaName);
                annualCostDataVo.setUsedNetworkQuota(count);
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(annualCostDataVo.getNetworkQuota()) && ObjectUtils.isNotEmpty(count)) {
                    double usedRate = (count / annualCostDataVo.getNetworkQuota()) * 100;
                    annualCostDataVo.setProgressNetworkQuota(String.format("%.2f", usedRate) + "%");
                }
            }
            // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressNetworkQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressNetworkQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名  网络产品增收暂时没有排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressNetworkQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressNetworkQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankNetworkQuota(rank);
                    lastUsedRate = usedRate;
                }
            }
            return annualCostDataVoList;


        }else {
            //查询的是该年该月的数据，使用月度网络产品增收即可
            QueryWrapper<CostData> costDataQueryWrapper = new QueryWrapper<>();
            costDataQueryWrapper.eq("cost_year", year);
            costDataQueryWrapper.eq("cost_month", costRequest.getMonth());
            List<CostData> costData = costDataMapper.selectList(costDataQueryWrapper);
            if (CollectionUtils.isEmpty(costData)) {
                throw new RuntimeException("该年月没有数据");
            }
            //创建返回对象列表
            List<AnnualCostDataVo> annualCostDataVoList = new ArrayList<>();
            //遍历每月成本数据，获取每月网络产品增收情况
            for (CostData costDatum : costData) {
                //创建返回对象
                AnnualCostDataVo annualCostDataVo = new AnnualCostDataVo();
                //设置区域名称
                annualCostDataVo.setDistrict(costDatum.getDistrict());
                //设置月度网络产品增收额度
                annualCostDataVo.setNetworkQuota(costDatum.getNetworkQuota());
                //实际使用情况
                annualCostDataVo.setUsedNetworkQuota(costDatum.getNetworkUsed());
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(costDatum.getNetworkQuota()) && ObjectUtils.isNotEmpty(costDatum.getNetworkUsed())) {
                    double usedRate = (costDatum.getNetworkUsed() / costDatum.getNetworkQuota()) * 100;
                    annualCostDataVo.setProgressNetworkQuota(String.format("%.2f", usedRate) + "%");
                }
                annualCostDataVoList.add(annualCostDataVo);
            }

            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressNetworkQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressNetworkQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressNetworkQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressNetworkQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankNetworkQuota(rank);
                    lastUsedRate = usedRate;
                }

            }
            return annualCostDataVoList;
        }
    }




    private List<AnnualCostDataVo> getTowerCostDataVos(CostRequest costRequest, int year) {
        //判断是不是查询月份数据
        if (ObjectUtils.isEmpty(costRequest.getMonth())) {
            //查询年度塔费数据
            List<AnnualCostDataVo> annualCostDataVoList = annualCostDataMapper.selectYear(year);
            //判断集合是否为空
            if (CollectionUtils.isEmpty(annualCostDataVoList)) {
                throw new RuntimeException("该年份没有数据");
            }
            //对数据进行遍历，获取实际使用情况
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                //获取区域名称
                String areaName = annualCostDataVo.getDistrict();
                //根据区域名称获取当年实际的塔费使用情况
                Double count = costDataMapper.selectCountByAreaAndYear(year, areaName);
                annualCostDataVo.setUsedTowerQuota(count);
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(annualCostDataVo.getTowerQuota()) && ObjectUtils.isNotEmpty(count)) {
                    double usedRate = (count / annualCostDataVo.getTowerQuota()) * 100;
                    annualCostDataVo.setProgressTowerQuota(String.format("%.2f", usedRate) + "%");
                }
            }
            // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressTowerQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressTowerQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名  塔费暂时没有排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressTowerQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressTowerQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankTowerQuota(rank);
                    lastUsedRate = usedRate;
                }
            }
            return annualCostDataVoList;


    }else {
            //查询的是该年该月的数据，使用月度塔费即可
            QueryWrapper<CostData> costDataQueryWrapper = new QueryWrapper<>();
            costDataQueryWrapper.eq("cost_year", year);
            costDataQueryWrapper.eq("cost_month", costRequest.getMonth());
            List<CostData> costData = costDataMapper.selectList(costDataQueryWrapper);
            if (CollectionUtils.isEmpty(costData)) {
                throw new RuntimeException("该年月没有数据");
            }
            //创建返回对象列表
            List<AnnualCostDataVo> annualCostDataVoList = new ArrayList<>();
            //遍历每月成本数据，获取每月塔费用使用情况
            for (CostData costDatum : costData) {
                //创建返回对象
                AnnualCostDataVo annualCostDataVo = new AnnualCostDataVo();
                //设置区域名称
                annualCostDataVo.setDistrict(costDatum.getDistrict());
                //设置月度塔费额度
                annualCostDataVo.setTowerQuota(costDatum.getTowerQuota());
                //实际使用情况
                annualCostDataVo.setUsedTowerQuota(costDatum.getTowerUsed());
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(costDatum.getTowerQuota()) && ObjectUtils.isNotEmpty(costDatum.getTowerUsed())) {
                    double usedRate = (costDatum.getTowerUsed() / costDatum.getTowerQuota()) * 100;
                    annualCostDataVo.setProgressTowerQuota(String.format("%.2f", usedRate) + "%");
                }
                annualCostDataVoList.add(annualCostDataVo);
            }

            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressTowerQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressTowerQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressTowerQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressTowerQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankTowerQuota(rank);
                    lastUsedRate = usedRate;
                }

            }
            return annualCostDataVoList;
        }
    }

    private List<AnnualCostDataVo> getelectricCostDataVos(CostRequest costRequest, int year) {
        //判断是不是查询月份数据
        if (ObjectUtils.isEmpty(costRequest.getMonth())) {
            //查询年度电费数据
            List<AnnualCostDataVo> annualCostDataVoList = annualCostDataMapper.selectYear(year);
            //判断集合是否为空
            if (CollectionUtils.isEmpty(annualCostDataVoList)) {
                throw new RuntimeException("该年份没有数据");
            }
            //对数据进行遍历，获取实际使用情况
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                //获取区域名称
                String areaName = annualCostDataVo.getDistrict();
                //根据区域名称获取当年实际的电费使用情况
                Double count = costDataMapper.countElectricCostByAreaAndYear(year, areaName);
                annualCostDataVo.setUsedElectricQuota(count);
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(annualCostDataVo.getElectricQuota()) && ObjectUtils.isNotEmpty(count)) {
                    double usedRate = (count / annualCostDataVo.getElectricQuota()) * 100;
                    annualCostDataVo.setProgressElectricQuota(String.format("%.2f", usedRate) + "%");
                }
            }
            // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
            annualCostDataVoList.sort((o1, o2) -> {
                double usedRate1 = Double.parseDouble(o1.getProgressElectricQuota().replace("%", ""));
                double usedRate2 = Double.parseDouble(o2.getProgressElectricQuota().replace("%", ""));
                if (usedRate1 == usedRate2) {
                    return 0; // 使用率相同，不改变它们的相对顺序
                } else {
                    return Double.compare(usedRate1, usedRate2);
                }
            });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
            int rank = 1;
            double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressElectricQuota().replace("%", ""));
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                double usedRate = Double.parseDouble(annualCostDataVo.getProgressElectricQuota().replace("%", ""));
                if (usedRate != lastUsedRate) {
                    rank++; // 只有使用率改变时，排名才递增
                }
                annualCostDataVo.setRankElectricQuota(rank);
                lastUsedRate = usedRate;
            }
            return annualCostDataVoList;

        } else {
            //查询的是该年该月的数据，使用月度电费即可
            QueryWrapper<CostData> costDataQueryWrapper = new QueryWrapper<>();
            costDataQueryWrapper.eq("cost_year", year);
            costDataQueryWrapper.eq("cost_month", costRequest.getMonth());
            List<CostData> costData = costDataMapper.selectList(costDataQueryWrapper);
            if (CollectionUtils.isEmpty(costData)) {
                throw new RuntimeException("该年月没有数据");
            }
            //创建返回对象列表
            List<AnnualCostDataVo> annualCostDataVoList = new ArrayList<>();
            //遍历每月成本数据，获取每月电费用使用情况
            for (CostData costDatum : costData) {
                //创建返回对象
                AnnualCostDataVo annualCostDataVo = new AnnualCostDataVo();
                //设置区域名称
                annualCostDataVo.setDistrict(costDatum.getDistrict());
                //设置月度电费额度
                annualCostDataVo.setElectricQuota(costDatum.getElectricQuota());
                //实际使用情况
                annualCostDataVo.setUsedElectricQuota(costDatum.getElectricUsed());
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(costDatum.getElectricQuota()) && ObjectUtils.isNotEmpty(costDatum.getElectricUsed())) {
                    double usedRate = (costDatum.getElectricUsed() / costDatum.getElectricQuota()) * 100;
                    annualCostDataVo.setProgressElectricQuota(String.format("%.2f", usedRate) + "%");
                }
                annualCostDataVoList.add(annualCostDataVo);
            }
            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressElectricQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressElectricQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressElectricQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressElectricQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankElectricQuota(rank);
                    lastUsedRate = usedRate;
                }

            }
            return annualCostDataVoList;
        }
    }

    private List<AnnualCostDataVo> getCostDataVos(CostRequest costRequest, int year) {
        if (ObjectUtils.isEmpty(costRequest.getMonth())) {
            //选择的是查询年份的成本维修费，他的月份为空


//        获取当年的年度总成本
            List<AnnualCostDataVo> annualCostDataVoList = annualCostDataMapper.selectYear(year);
            //判断集合是否为空
            if (CollectionUtils.isEmpty(annualCostDataVoList)) {
                throw new RuntimeException("该年份没有数据");
            }
            //对数据进行遍历，获取实际使用情况
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                //获取区域名称
                String areaName = annualCostDataVo.getDistrict();
                //根据区域名称获取当年实际的维修费使用情况
                Double count = costDataMapper.countCostByAreaAndYear(year, areaName);
                annualCostDataVo.setUsedRepairQuota(count);
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(annualCostDataVo.getTotalRepairQuota()) && ObjectUtils.isNotEmpty(count)) {
                    double usedRate = (count / annualCostDataVo.getTotalRepairQuota()) * 100;
                    annualCostDataVo.setProgressRepairQuota(String.format("%.2f", usedRate) + "%");
                }
            }
            // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
            annualCostDataVoList.sort((o1, o2) -> {
                double usedRate1 = Double.parseDouble(o1.getProgressRepairQuota().replace("%", ""));
                double usedRate2 = Double.parseDouble(o2.getProgressRepairQuota().replace("%", ""));
                if (usedRate1 == usedRate2) {
                    return 0; // 使用率相同，不改变它们的相对顺序
                } else {
                    return Double.compare(usedRate1, usedRate2);
                }
            });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
            int rank = 1;
            double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressRepairQuota().replace("%", ""));
            for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                double usedRate = Double.parseDouble(annualCostDataVo.getProgressRepairQuota().replace("%", ""));
                if (usedRate != lastUsedRate) {
                    rank++; // 只有使用率改变时，排名才递增
                }
                annualCostDataVo.setRankRepairQuota(rank);
                lastUsedRate = usedRate;
            }

            return annualCostDataVoList;
        } else {
            //查询的是该年该月的数据，使用月度成本即可
            QueryWrapper<CostData> costDataQueryWrapper = new QueryWrapper<>();
            costDataQueryWrapper.eq("cost_year", year);
            costDataQueryWrapper.eq("cost_month", costRequest.getMonth());
            List<CostData> costData = costDataMapper.selectList(costDataQueryWrapper);
            if (CollectionUtils.isEmpty(costData)) {
                throw new RuntimeException("该年月没有数据");
            }
            //创建返回对象列表
            List<AnnualCostDataVo> annualCostDataVoList = new ArrayList<>();
            //遍历每月成本数据，获取每月维修费用使用情况
            for (CostData costDatum : costData) {
                //创建返回对象
                AnnualCostDataVo annualCostDataVo = new AnnualCostDataVo();
                //设置区域名称
                annualCostDataVo.setDistrict(costDatum.getDistrict());
                //设置月度维修费额度
                annualCostDataVo.setTotalRepairQuota(costDatum.getRepairQuota());
                //实际使用情况
                annualCostDataVo.setUsedRepairQuota(costDatum.getRepairUsed());
                //计算使用率，转换成百分数 如10%,保留两位小数
                if (ObjectUtils.isNotEmpty(costDatum.getRepairQuota()) && ObjectUtils.isNotEmpty(costDatum.getRepairUsed())) {
                    double usedRate = (costDatum.getRepairUsed() / costDatum.getRepairQuota()) * 100;
                    annualCostDataVo.setProgressRepairQuota(String.format("%.2f", usedRate) + "%");
                }
                annualCostDataVoList.add(annualCostDataVo);
            }
            if (!CollectionUtils.isEmpty(annualCostDataVoList)) {
                // 先根据使用率对集合进行排序，使用率低的排在前面，使用率相同的情况下保持原来的相对顺序
                annualCostDataVoList.sort((o1, o2) -> {
                    double usedRate1 = Double.parseDouble(o1.getProgressRepairQuota().replace("%", ""));
                    double usedRate2 = Double.parseDouble(o2.getProgressRepairQuota().replace("%", ""));
                    if (usedRate1 == usedRate2) {
                        return 0; // 使用率相同，不改变它们的相对顺序
                    } else {
                        return Double.compare(usedRate1, usedRate2);
                    }
                });

// 排序后遍历集合，设置排名，使用率相同的对象赋予相同的排名
                int rank = 1;
                double lastUsedRate = Double.parseDouble(annualCostDataVoList.get(0).getProgressRepairQuota().replace("%", ""));
                for (AnnualCostDataVo annualCostDataVo : annualCostDataVoList) {
                    double usedRate = Double.parseDouble(annualCostDataVo.getProgressRepairQuota().replace("%", ""));
                    if (usedRate != lastUsedRate) {
                        rank++; // 只有使用率改变时，排名才递增
                    }
                    annualCostDataVo.setRankRepairQuota(rank);
                    lastUsedRate = usedRate;
                }
            }
            return annualCostDataVoList;

        }
    }
}
